home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / src / Scanner.mi < prev    next >
Text File  |  1992-11-24  |  40KB  |  1,575 lines
  1. (* $Id: Scanner.mi,v 2.11 1992/09/24 13:14:00 grosch rel $ *)
  2.  
  3. IMPLEMENTATION MODULE Scanner;
  4.  
  5. IMPORT SYSTEM, Checks, System, General, Positions, IO, DynArray, Strings, Source;
  6. (* line 26 "cg.rex" *)
  7.  
  8.  
  9. FROM SYSTEM    IMPORT ADR;
  10. FROM System    IMPORT GetArgument;
  11. FROM StringMem    IMPORT PutString;
  12. FROM Strings    IMPORT tString, Concatenate, Char, SubString, ArrayToString,
  13.             StringToInt, AssignEmpty, Length;
  14. FROM Idents    IMPORT MakeIdent, NoIdent, GetStringRef;
  15. FROM Texts    IMPORT MakeText, Append;
  16. FROM Tree    IMPORT Options, ErrorCount, SourceFile;
  17. FROM Sets    IMPORT IsElement;
  18. FROM Positions    IMPORT tPosition;
  19.  
  20. IMPORT Errors;
  21.  
  22. CONST
  23.    TokIdentifier     = 1;
  24.    TokInteger         = 2;
  25.    TokString         = 3;
  26.    TokTargetCode    = 4;
  27.    TokCode        = 5;
  28.    TokWhiteSpace    = 7;
  29.  
  30.    TokAfter        = 24;
  31.    TokBefore        = 25;
  32.    TokBegin        = 10;
  33.    TokCheck        = 26;
  34.    TokClose        = 11;
  35.    TokDeclare        = 12;
  36.    TokDemand        = 28;
  37.    TokEnd        = 13;
  38.    TokEval        = 14;
  39.    TokExport        = 15;
  40.    TokFor        = 71;
  41.    TokFunction        = 6;
  42.    TokGlobal        = 16;
  43.    TokIgnore        = 72;
  44.    TokImport        = 30;
  45.    TokInherited        = 34;
  46.    TokInput        = 31;
  47.    TokLeft        = 37;
  48.    TokLocal        = 18;
  49.    TokModule        = 19;
  50.    TokNone        = 39;
  51.    TokOutput        = 32;
  52.    TokParser        = 35;
  53.    TokPrec        = 36;
  54.    TokProperty        = 70;
  55.    TokRemote        = 76;
  56.    TokReverse        = 21;
  57.    TokRight        = 38;
  58.    TokRule        = 22;
  59.    TokScanner        = 77;
  60.    TokSelect        = 74;
  61.    TokStack        = 20;
  62.    TokSubunit        = 75;
  63.    TokSynthesized    = 33;
  64.    TokThread        = 27;
  65.    TokTree        = 23;
  66.    TokView        = 78;
  67.    TokVirtual        = 17;
  68.  
  69.    TokLParent        = 40;    (* '('            *)
  70.    TokRParent        = 41;    (* ')'            *)
  71.    TokLBracket        = 42;    (* '['            *)
  72.    TokRBracket        = 43;    (* ']'            *)
  73.    TokLBrace        = 44;    (* '{'            *)
  74.    TokRBrace        = 45;    (* '}'            *)
  75.    TokComma        = 46;    (* ','            *)
  76.    TokSemiColon        = 47;    (* ';'            *)
  77.    TokDot        = 48;    (* '.'            *)
  78.    TokColon        = 49;    (* ':'            *)
  79.    TokEqual        = 50;    (* '='            *)
  80.    TokBar        = 51;    (* '|'            *) (* ? *)
  81.    TokAssign        = 52;    (* ':='            *)
  82.    TokPlus        = 53;    (* '+'            *) (* ? *)
  83.    TokMinus        = 54;    (* '-'            *) (* ? *)
  84.    TokAsterisk        = 55;    (* '*'            *) (* ? *)
  85.    TokSlash        = 56;    (* '/'            *) (* ? *)
  86.    TokLAngle        = 57;    (* '<'            *)
  87.    TokRAngle        = 58;    (* '>'            *)
  88.    TokRArrow        = 59;    (* '->'            *)
  89.    TokCopy        = 60;    (* ':-'            *)
  90.    TokArrow        = 61;    (* '==>'        *)
  91.    TokLArrow        = 62;    (* '<-'            *)
  92.  
  93. PROCEDURE ErrorAttribute (Token: CARDINAL; VAR Attribute: tScanAttribute);
  94.    BEGIN
  95.       WITH Attribute DO
  96.      CASE Token OF
  97.      | TokIdentifier: Ident        := NoIdent;
  98.      | TokInteger    : Integer    := 0;
  99.      | TokTargetCode: MakeText (Text);
  100.      | TokString
  101.         , TokCode
  102.         , TokWhiteSpace: StringRef    := GetStringRef (NoIdent);
  103.      ELSE
  104.      END;
  105.       END;
  106.    END ErrorAttribute;
  107.  
  108. VAR NestingLevel: INTEGER; Position: tPosition;
  109.  
  110.  
  111. CONST
  112.    yyTabSpace        = 8;
  113.    yyDNoState        = 0;
  114.    yyFileStackSize    = 16;
  115.    yyInitBufferSize    = 1024 * 8 + 256;
  116. yyFirstCh    = 0C;
  117. yyLastCh    = 177C;
  118. yyEolCh    = 12C;
  119. yyEobCh    = 177C;
  120. yyDStateCount    = 292;
  121. yyTableSize    = 3035;
  122. yyEobState    = 91;
  123. yyDefaultState    = 92;
  124. STD    = 1;
  125. comment    = 3;
  126. Str1    = 5;
  127. Str2    = 7;
  128. CStr1    = 9;
  129. CStr2    = 11;
  130. targetcode    = 13;
  131. expr    = 15;
  132.  
  133. TYPE
  134.    yyTableElmt        = SHORTCARD;
  135.    yyStateRange        = yyTableElmt [0 .. yyDStateCount];
  136.    yyTableRange        = yyTableElmt [0 .. yyTableSize];
  137.    yyCombType        = RECORD Check, Next: yyStateRange; END;
  138.    yyCombTypePtr    = POINTER TO yyCombType;
  139.    yytChBufferPtr    = POINTER TO ARRAY [0 .. 1000000] OF CHAR;
  140.    yyChRange        = [yyFirstCh .. yyLastCh];
  141.  
  142. VAR
  143.    yyBasePtr        : ARRAY yyStateRange    OF LONGCARD    ;
  144.    yyDefault        : ARRAY yyStateRange    OF yyStateRange    ;
  145.    yyComb        : ARRAY yyTableRange    OF yyCombType    ;
  146.    yyEobTrans        : ARRAY yyStateRange    OF yyStateRange    ;
  147.    yyToLower, yyToUpper    : ARRAY yyChRange    OF CHAR        ;
  148.  
  149.    yyStateStack        : POINTER TO ARRAY [0 .. 1000000] OF yyStateRange;
  150.    yyStateStackSize    : LONGINT;
  151.    yyStartState        : yyStateRange;
  152.    yyPreviousStart    : yyStateRange;
  153.    yyCh            : CHAR;
  154.  
  155.    yySourceFile        : System.tFile;
  156.    yyEof        : BOOLEAN;
  157.    yyChBufferPtr    : yytChBufferPtr;
  158.    yyChBufferStart    : INTEGER;
  159.    yyChBufferSize    : LONGINT;
  160.    yyChBufferIndex    : INTEGER;
  161.    yyBytesRead        : INTEGER;
  162.    yyLineCount        : CARDINAL;
  163.    yyLineStart        : INTEGER;
  164.  
  165.    yyFileStackPtr    : SHORTCARD;
  166.    yyFileStack        : ARRAY [1 .. yyFileStackSize] OF RECORD
  167.                     SourceFile        : System.tFile;
  168.                  Eof        : BOOLEAN;
  169.                     ChBufferPtr    : yytChBufferPtr;
  170.                  ChBufferStart    : INTEGER;
  171.                  ChBufferSize    : LONGINT;
  172.                     ChBufferIndex    : INTEGER;
  173.                     BytesRead        : INTEGER;
  174.                     LineCount        : CARDINAL;
  175.                     LineStart        : INTEGER;
  176.               END;
  177.  
  178. PROCEDURE GetToken (): INTEGER;
  179.    VAR
  180.       yyState        : yyStateRange;
  181.       yyTablePtr    : yyCombTypePtr;
  182.       yyRestartFlag    : BOOLEAN;
  183.       yyi, yySource, yyTarget, yyChBufferFree    : INTEGER;
  184. (* line 130 "cg.rex" *)
  185.  
  186. VAR
  187.    String, Word, TargetCode: tString;
  188.    Argument    : ARRAY [0..255] OF CHAR;
  189.    j        : SHORTCARD;
  190.    ch        : CHAR;
  191.  
  192. BEGIN
  193.    LOOP
  194.       yyState        := yyStartState;
  195.       TokenLength     := 0;
  196.  
  197.       (* ASSERT yyChBuffer [yyChBufferIndex] = first character *)
  198.  
  199.       LOOP        (* eventually restart after sentinel *)
  200.      LOOP        (* execute as many state transitions as possible *)
  201.                             (* determine next state *)
  202.         yyTablePtr := yyCombTypePtr (yyBasePtr [yyState] +
  203.            ORD (yyChBufferPtr^ [yyChBufferIndex]) * SYSTEM.TSIZE (yyCombType));
  204.         IF yyTablePtr^.Check # yyState THEN
  205.            yyState := yyDefault [yyState];
  206.            IF yyState = yyDNoState THEN EXIT; END;
  207.         ELSE
  208.            yyState := yyTablePtr^.Next;
  209.            INC (TokenLength);
  210.            yyStateStack^ [TokenLength] := yyState;    (* push state *)
  211.            INC (yyChBufferIndex);        (* get next character *)
  212.         END;
  213.      END;
  214.  
  215.      LOOP                    (* search for last final state *)
  216. CASE yyStateStack^ [TokenLength] OF
  217. |292
  218. :
  219. Attribute.Position.Line   := yyLineCount;
  220. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  221. (* line 190 "cg.rex" *)
  222.  
  223.                IF NestingLevel = 0 THEN
  224.                   MakeText (Attribute.Text);
  225.                   AssignEmpty (TargetCode);
  226.                   Position := Attribute.Position;
  227.                ELSE
  228.                   GetWord (Word);
  229.                   Concatenate (TargetCode, Word);
  230.                END;
  231.                INC (NestingLevel);
  232.             
  233. yyRestartFlag := FALSE; EXIT;
  234. |291
  235. :
  236. (* line 202 "cg.rex" *)
  237.  
  238.                DEC (NestingLevel);
  239.                IF NestingLevel = 0 THEN
  240.                   yyStart (STD);
  241.                   Append (Attribute.Text, TargetCode);
  242.                   Attribute.Position := Position;
  243.                   RETURN TokTargetCode;
  244.                ELSE
  245.                   GetWord (Word);
  246.                   Concatenate (TargetCode, Word);
  247.                END;
  248.             
  249. yyRestartFlag := FALSE; EXIT;
  250. |24
  251. ,101
  252. :
  253. (* line 215 "cg.rex" *)
  254.  
  255.                IF NestingLevel > 0 THEN
  256.                   GetWord (Word);
  257.                   Concatenate (TargetCode, Word);
  258.                END;
  259.             
  260. yyRestartFlag := FALSE; EXIT;
  261. |290
  262. :
  263. (* line 222 "cg.rex" *)
  264.  
  265.                IF NestingLevel > 0 THEN
  266.                   Strings.Append (TargetCode, 11C);
  267.                END;
  268.                yyTab;
  269.             
  270. yyRestartFlag := FALSE; EXIT;
  271. |289
  272. :
  273. (* line 229 "cg.rex" *)
  274.  
  275.                IF NestingLevel > 0 THEN
  276.                   Append (Attribute.Text, TargetCode);
  277.                   AssignEmpty (TargetCode);
  278.                END;
  279.                yyEol (0);
  280.             
  281. yyRestartFlag := FALSE; EXIT;
  282. |25
  283. :
  284. (* line 237 "cg.rex" *)
  285.  
  286.                IF NestingLevel > 0 THEN
  287.                   GetWord (Word);
  288.                   Strings.Append (TargetCode, Char (Word, 2));
  289.                END;
  290.             
  291. yyRestartFlag := FALSE; EXIT;
  292. |44
  293. :
  294. (* line 244 "cg.rex" *)
  295.  
  296.                IF NestingLevel > 0 THEN
  297.                   Strings.Append (TargetCode, '\');
  298.                END;
  299.             
  300. yyRestartFlag := FALSE; EXIT;
  301. |288
  302. :
  303. (* line 250 "cg.rex" *)
  304. yyStart (comment);
  305. yyRestartFlag := FALSE; EXIT;
  306. |286
  307. :
  308. (* line 251 "cg.rex" *)
  309. yyPrevious;
  310. yyRestartFlag := FALSE; EXIT;
  311. |30
  312. ,50
  313. ,96
  314. :
  315. (* line 252 "cg.rex" *)
  316.  
  317. yyRestartFlag := FALSE; EXIT;
  318. |32
  319. :
  320. (* line 254 "cg.rex" *)
  321.  
  322. yyRestartFlag := FALSE; EXIT;
  323. |31
  324. :
  325. Attribute.Position.Line   := yyLineCount;
  326. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  327. (* line 256 "cg.rex" *)
  328. GetWord (Word);
  329.                        Attribute.Integer := StringToInt (Word);
  330.                RETURN TokInteger;
  331. yyRestartFlag := FALSE; EXIT;
  332. |285
  333. :
  334. Attribute.Position.Line   := yyLineCount;
  335. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  336. (* line 260 "cg.rex" *)
  337. GetWord (String);
  338.                 IF IsElement (ORD ('c'), Options)
  339.                 THEN yyStart (CStr1);
  340.                 ELSE yyStart (Str1);
  341.                 END;
  342. yyRestartFlag := FALSE; EXIT;
  343. |284
  344. :
  345. Attribute.Position.Line   := yyLineCount;
  346. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  347. (* line 266 "cg.rex" *)
  348. GetWord (String);
  349.                 IF IsElement (ORD ('c'), Options)
  350.                 THEN yyStart (CStr2);
  351.                 ELSE yyStart (Str2);
  352.                 END;
  353. yyRestartFlag := FALSE; EXIT;
  354. |29
  355. ,97
  356. :
  357. (* line 275 "cg.rex" *)
  358. GetWord (Word); Concatenate (String, Word);
  359. yyRestartFlag := FALSE; EXIT;
  360. |28
  361. ,98
  362. :
  363. (* line 275 "cg.rex" *)
  364. GetWord (Word); Concatenate (String, Word);
  365. yyRestartFlag := FALSE; EXIT;
  366. |27
  367. ,49
  368. ,71
  369. ,99
  370. :
  371. (* line 275 "cg.rex" *)
  372. GetWord (Word); Concatenate (String, Word);
  373. yyRestartFlag := FALSE; EXIT;
  374. |26
  375. ,48
  376. ,70
  377. ,100
  378. :
  379. (* line 275 "cg.rex" *)
  380. GetWord (Word); Concatenate (String, Word);
  381. yyRestartFlag := FALSE; EXIT;
  382. |283
  383. :
  384. (* line 278 "cg.rex" *)
  385. GetWord (Word); Concatenate (String, Word); yyEol (0);
  386. yyRestartFlag := FALSE; EXIT;
  387. |282
  388. :
  389. (* line 278 "cg.rex" *)
  390. GetWord (Word); Concatenate (String, Word); yyEol (0);
  391. yyRestartFlag := FALSE; EXIT;
  392. |281
  393. :
  394. (* line 281 "cg.rex" *)
  395. Strings.Append (String, Char (String, 1));
  396.                 yyPrevious;
  397.                 IF yyStartState = targetcode THEN
  398.                    Concatenate (TargetCode, String);
  399.                 ELSE
  400.                    Attribute.StringRef := PutString (String);
  401.                    RETURN TokString;
  402.                 END;
  403. yyRestartFlag := FALSE; EXIT;
  404. |280
  405. :
  406. (* line 281 "cg.rex" *)
  407. Strings.Append (String, Char (String, 1));
  408.                 yyPrevious;
  409.                 IF yyStartState = targetcode THEN
  410.                    Concatenate (TargetCode, String);
  411.                 ELSE
  412.                    Attribute.StringRef := PutString (String);
  413.                    RETURN TokString;
  414.                 END;
  415. yyRestartFlag := FALSE; EXIT;
  416. |279
  417. :
  418. (* line 290 "cg.rex" *)
  419. Strings.Append (String, 11C); yyTab;
  420. yyRestartFlag := FALSE; EXIT;
  421. |278
  422. :
  423. (* line 292 "cg.rex" *)
  424.  
  425.                 Errors.Message ("unclosed string", Errors.Error, Attribute.Position);
  426.                 INC (ErrorCount);
  427.                 Strings.Append (String, Char (String, 1));
  428.                 yyEol (0); yyPrevious;
  429.                 IF yyStartState = targetcode THEN
  430.                    Concatenate (TargetCode, String);
  431.                 ELSE
  432.                    Attribute.StringRef := PutString (String);
  433.                    RETURN TokString;
  434.                 END;
  435. yyRestartFlag := FALSE; EXIT;
  436. |277
  437. :
  438. Attribute.Position.Line   := yyLineCount;
  439. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  440. (* line 304 "cg.rex" *)
  441. RETURN TokLParent        ;
  442. yyRestartFlag := FALSE; EXIT;
  443. |276
  444. :
  445. Attribute.Position.Line   := yyLineCount;
  446. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  447. (* line 305 "cg.rex" *)
  448. RETURN TokRParent        ;
  449. yyRestartFlag := FALSE; EXIT;
  450. |275
  451. :
  452. Attribute.Position.Line   := yyLineCount;
  453. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  454. (* line 306 "cg.rex" *)
  455. RETURN TokComma        ;
  456. yyRestartFlag := FALSE; EXIT;
  457. |274
  458. :
  459. Attribute.Position.Line   := yyLineCount;
  460. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  461. (* line 307 "cg.rex" *)
  462. RETURN TokRArrow        ;
  463. yyRestartFlag := FALSE; EXIT;
  464. |272
  465. :
  466. Attribute.Position.Line   := yyLineCount;
  467. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  468. (* line 308 "cg.rex" *)
  469. RETURN TokDot        ;
  470. yyRestartFlag := FALSE; EXIT;
  471. |241
  472. :
  473. Attribute.Position.Line   := yyLineCount;
  474. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  475. (* line 309 "cg.rex" *)
  476. RETURN TokColon        ;
  477. yyRestartFlag := FALSE; EXIT;
  478. |270
  479. :
  480. Attribute.Position.Line   := yyLineCount;
  481. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  482. (* line 310 "cg.rex" *)
  483. RETURN TokLAngle        ;
  484. yyRestartFlag := FALSE; EXIT;
  485. |271
  486. :
  487. Attribute.Position.Line   := yyLineCount;
  488. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  489. (* line 311 "cg.rex" *)
  490. RETURN TokLArrow        ;
  491. yyRestartFlag := FALSE; EXIT;
  492. |269
  493. :
  494. Attribute.Position.Line   := yyLineCount;
  495. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  496. (* line 312 "cg.rex" *)
  497. RETURN TokEqual        ;
  498. yyRestartFlag := FALSE; EXIT;
  499. |268
  500. :
  501. Attribute.Position.Line   := yyLineCount;
  502. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  503. (* line 313 "cg.rex" *)
  504. RETURN TokRAngle        ;
  505. yyRestartFlag := FALSE; EXIT;
  506. |267
  507. :
  508. Attribute.Position.Line   := yyLineCount;
  509. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  510. (* line 314 "cg.rex" *)
  511. RETURN TokLBracket        ;
  512. yyRestartFlag := FALSE; EXIT;
  513. |266
  514. :
  515. Attribute.Position.Line   := yyLineCount;
  516. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  517. (* line 315 "cg.rex" *)
  518. RETURN TokRBracket        ;
  519. yyRestartFlag := FALSE; EXIT;
  520. |265
  521. :
  522. Attribute.Position.Line   := yyLineCount;
  523. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  524. (* line 316 "cg.rex" *)
  525. yyStart (expr); INC (NestingLevel); RETURN TokLBrace;
  526. yyRestartFlag := FALSE; EXIT;
  527. |264
  528. :
  529. Attribute.Position.Line   := yyLineCount;
  530. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  531. (* line 318 "cg.rex" *)
  532. RETURN TokAfter        ;
  533. yyRestartFlag := FALSE; EXIT;
  534. |259
  535. :
  536. Attribute.Position.Line   := yyLineCount;
  537. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  538. (* line 319 "cg.rex" *)
  539. RETURN TokBefore        ;
  540. yyRestartFlag := FALSE; EXIT;
  541. |253
  542. :
  543. Attribute.Position.Line   := yyLineCount;
  544. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  545. (* line 320 "cg.rex" *)
  546. RETURN TokCheck        ;
  547. yyRestartFlag := FALSE; EXIT;
  548. |248
  549. :
  550. Attribute.Position.Line   := yyLineCount;
  551. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  552. (* line 321 "cg.rex" *)
  553. RETURN TokRemote        ;
  554. yyRestartFlag := FALSE; EXIT;
  555. |18
  556. ,43
  557. :
  558. Attribute.Position.Line   := yyLineCount;
  559. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  560. (* line 323 "cg.rex" *)
  561. GetWord (Word);
  562.                Attribute.StringRef := PutString (Word);
  563.                RETURN TokCode;
  564. yyRestartFlag := FALSE; EXIT;
  565. |242
  566. :
  567. Attribute.Position.Line   := yyLineCount;
  568. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  569. (* line 327 "cg.rex" *)
  570. IF NestingLevel <= 1 THEN
  571.                   RETURN TokAssign;
  572.                ELSE
  573.                   GetWord (Word);
  574.                   Attribute.StringRef := PutString (Word);
  575.                   RETURN TokCode;
  576.                END;
  577. yyRestartFlag := FALSE; EXIT;
  578. |240
  579. :
  580. Attribute.Position.Line   := yyLineCount;
  581. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  582. (* line 335 "cg.rex" *)
  583. IF NestingLevel <= 1 THEN
  584.                   RETURN TokCopy;
  585.                ELSE
  586.                   GetWord (Word);
  587.                   Attribute.StringRef := PutString (Word);
  588.                   RETURN TokCode;
  589.                END;
  590. yyRestartFlag := FALSE; EXIT;
  591. |239
  592. :
  593. Attribute.Position.Line   := yyLineCount;
  594. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  595. (* line 343 "cg.rex" *)
  596. IF NestingLevel <= 1 THEN
  597.                   RETURN TokSemiColon;
  598.                ELSE
  599.                   GetWord (Word);
  600.                   Attribute.StringRef := PutString (Word);
  601.                   RETURN TokCode;
  602.                END;
  603. yyRestartFlag := FALSE; EXIT;
  604. |238
  605. :
  606. Attribute.Position.Line   := yyLineCount;
  607. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  608. (* line 351 "cg.rex" *)
  609. GetWord (Word);
  610.                Attribute.StringRef := PutString (Word);
  611.                RETURN TokColon;
  612. yyRestartFlag := FALSE; EXIT;
  613. |23
  614. :
  615. Attribute.Position.Line   := yyLineCount;
  616. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  617. (* line 355 "cg.rex" *)
  618. RETURN TokArrow;
  619. yyRestartFlag := FALSE; EXIT;
  620. |237
  621. :
  622. Attribute.Position.Line   := yyLineCount;
  623. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  624. (* line 357 "cg.rex" *)
  625. INC (NestingLevel);
  626.                IF NestingLevel <= 2 THEN
  627.                   RETURN TokLBrace;
  628.                ELSE
  629.                   GetWord (Word);
  630.                   Attribute.StringRef := PutString (Word);
  631.                   RETURN TokCode;
  632.                END;
  633. yyRestartFlag := FALSE; EXIT;
  634. |236
  635. :
  636. Attribute.Position.Line   := yyLineCount;
  637. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  638. (* line 366 "cg.rex" *)
  639. DEC (NestingLevel);
  640.                IF NestingLevel = 0 THEN yyStart (STD); END;
  641.                IF NestingLevel <= 1 THEN
  642.                   RETURN TokRBrace;
  643.                ELSE
  644.                   GetWord (Word);
  645.                   Attribute.StringRef := PutString (Word);
  646.                   RETURN TokCode;
  647.                END;
  648. yyRestartFlag := FALSE; EXIT;
  649. |235
  650. :
  651. Attribute.Position.Line   := yyLineCount;
  652. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  653. (* line 376 "cg.rex" *)
  654. GetWord (Word);
  655.                Attribute.StringRef := PutString (Word);
  656.                RETURN TokCode        ;
  657. yyRestartFlag := FALSE; EXIT;
  658. |45
  659. :
  660. Attribute.Position.Line   := yyLineCount;
  661. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  662. (* line 380 "cg.rex" *)
  663. GetWord (Word);
  664.                Attribute.StringRef := PutString (Word);
  665.                RETURN TokCode        ;
  666. yyRestartFlag := FALSE; EXIT;
  667. |19
  668. ,102
  669. :
  670. Attribute.Position.Line   := yyLineCount;
  671. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  672. (* line 384 "cg.rex" *)
  673. GetWord (Word);
  674.                Attribute.StringRef := PutString (Word);
  675.                RETURN TokWhiteSpace        ;
  676. yyRestartFlag := FALSE; EXIT;
  677. |234
  678. :
  679. Attribute.Position.Line   := yyLineCount;
  680. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  681. (* line 388 "cg.rex" *)
  682. GetWord (Word);
  683.                Attribute.StringRef := PutString (Word);
  684.                yyEol (0);
  685.                RETURN TokWhiteSpace        ;
  686. yyRestartFlag := FALSE; EXIT;
  687. |233
  688. :
  689. Attribute.Position.Line   := yyLineCount;
  690. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  691. (* line 393 "cg.rex" *)
  692. GetWord (Word);
  693.                Attribute.StringRef := PutString (Word);
  694.                yyTab;
  695.                RETURN TokWhiteSpace        ;
  696. yyRestartFlag := FALSE; EXIT;
  697. |21
  698. ,47
  699. :
  700. Attribute.Position.Line   := yyLineCount;
  701. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  702. (* line 398 "cg.rex" *)
  703. GetWord (Word);
  704.                SubString (Word, 2, 2, String);
  705.                Attribute.StringRef := PutString (String);
  706.                RETURN TokCode        ;
  707. yyRestartFlag := FALSE; EXIT;
  708. |22
  709. :
  710. Attribute.Position.Line   := yyLineCount;
  711. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  712. (* line 403 "cg.rex" *)
  713. GetWord (Word);
  714.                SubString (Word, 2, Length (Word), String);
  715.                Attribute.StringRef := PutString (String);
  716.                RETURN TokCode        ;
  717. yyRestartFlag := FALSE; EXIT;
  718. |46
  719. :
  720. Attribute.Position.Line   := yyLineCount;
  721. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  722. (* line 408 "cg.rex" *)
  723. GetWord (Word);
  724.                Attribute.StringRef := PutString (Word);
  725.                RETURN TokCode        ;
  726. yyRestartFlag := FALSE; EXIT;
  727. |232
  728. :
  729. Attribute.Position.Line   := yyLineCount;
  730. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  731. (* line 412 "cg.rex" *)
  732. yyStart (targetcode); RETURN TokBegin    ;
  733. yyRestartFlag := FALSE; EXIT;
  734. |227
  735. :
  736. Attribute.Position.Line   := yyLineCount;
  737. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  738. (* line 413 "cg.rex" *)
  739. yyStart (targetcode); RETURN TokClose    ;
  740. yyRestartFlag := FALSE; EXIT;
  741. |222
  742. :
  743. Attribute.Position.Line   := yyLineCount;
  744. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  745. (* line 414 "cg.rex" *)
  746. RETURN TokDeclare        ;
  747. yyRestartFlag := FALSE; EXIT;
  748. |217
  749. :
  750. Attribute.Position.Line   := yyLineCount;
  751. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  752. (* line 415 "cg.rex" *)
  753. RETURN TokDemand        ;
  754. yyRestartFlag := FALSE; EXIT;
  755. |211
  756. :
  757. Attribute.Position.Line   := yyLineCount;
  758. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  759. (* line 416 "cg.rex" *)
  760. RETURN TokEnd        ;
  761. yyRestartFlag := FALSE; EXIT;
  762. |209
  763. :
  764. Attribute.Position.Line   := yyLineCount;
  765. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  766. (* line 417 "cg.rex" *)
  767. RETURN TokEval        ;
  768. yyRestartFlag := FALSE; EXIT;
  769. |206
  770. :
  771. Attribute.Position.Line   := yyLineCount;
  772. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  773. (* line 418 "cg.rex" *)
  774. yyStart (targetcode); RETURN TokExport    ;
  775. yyRestartFlag := FALSE; EXIT;
  776. |200
  777. :
  778. Attribute.Position.Line   := yyLineCount;
  779. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  780. (* line 419 "cg.rex" *)
  781. RETURN TokFor        ;
  782. yyRestartFlag := FALSE; EXIT;
  783. |198
  784. :
  785. Attribute.Position.Line   := yyLineCount;
  786. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  787. (* line 420 "cg.rex" *)
  788. RETURN TokFunction        ;
  789. yyRestartFlag := FALSE; EXIT;
  790. |190
  791. :
  792. Attribute.Position.Line   := yyLineCount;
  793. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  794. (* line 421 "cg.rex" *)
  795. yyStart (targetcode); RETURN TokGlobal    ;
  796. yyRestartFlag := FALSE; EXIT;
  797. |184
  798. :
  799. Attribute.Position.Line   := yyLineCount;
  800. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  801. (* line 422 "cg.rex" *)
  802. RETURN TokIgnore        ;
  803. yyRestartFlag := FALSE; EXIT;
  804. |179
  805. :
  806. Attribute.Position.Line   := yyLineCount;
  807. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  808. (* line 423 "cg.rex" *)
  809. yyStart (targetcode); RETURN TokImport    ;
  810. yyRestartFlag := FALSE; EXIT;
  811. |38
  812. ,51
  813. :
  814. Attribute.Position.Line   := yyLineCount;
  815. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  816. (* line 424 "cg.rex" *)
  817. RETURN TokInput        ;
  818. yyRestartFlag := FALSE; EXIT;
  819. |39
  820. ,87
  821. :
  822. Attribute.Position.Line   := yyLineCount;
  823. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  824. (* line 425 "cg.rex" *)
  825. RETURN TokInherited        ;
  826. yyRestartFlag := FALSE; EXIT;
  827. |174
  828. :
  829. Attribute.Position.Line   := yyLineCount;
  830. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  831. (* line 426 "cg.rex" *)
  832. RETURN TokLeft        ;
  833. yyRestartFlag := FALSE; EXIT;
  834. |171
  835. :
  836. Attribute.Position.Line   := yyLineCount;
  837. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  838. (* line 427 "cg.rex" *)
  839. yyStart (targetcode); RETURN TokLocal    ;
  840. yyRestartFlag := FALSE; EXIT;
  841. |166
  842. :
  843. Attribute.Position.Line   := yyLineCount;
  844. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  845. (* line 428 "cg.rex" *)
  846. RETURN TokModule        ;
  847. yyRestartFlag := FALSE; EXIT;
  848. |160
  849. :
  850. Attribute.Position.Line   := yyLineCount;
  851. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  852. (* line 429 "cg.rex" *)
  853. RETURN TokNone        ;
  854. yyRestartFlag := FALSE; EXIT;
  855. |37
  856. ,72
  857. :
  858. Attribute.Position.Line   := yyLineCount;
  859. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  860. (* line 430 "cg.rex" *)
  861. RETURN TokOutput        ;
  862. yyRestartFlag := FALSE; EXIT;
  863. |156
  864. :
  865. Attribute.Position.Line   := yyLineCount;
  866. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  867. (* line 431 "cg.rex" *)
  868. RETURN TokParser        ;
  869. yyRestartFlag := FALSE; EXIT;
  870. |151
  871. :
  872. Attribute.Position.Line   := yyLineCount;
  873. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  874. (* line 432 "cg.rex" *)
  875. RETURN TokPrec        ;
  876. yyRestartFlag := FALSE; EXIT;
  877. |149
  878. :
  879. Attribute.Position.Line   := yyLineCount;
  880. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  881. (* line 433 "cg.rex" *)
  882. RETURN TokProperty        ;
  883. yyRestartFlag := FALSE; EXIT;
  884. |36
  885. ,86
  886. :
  887. Attribute.Position.Line   := yyLineCount;
  888. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  889. (* line 434 "cg.rex" *)
  890. RETURN TokReverse        ;
  891. yyRestartFlag := FALSE; EXIT;
  892. |141
  893. :
  894. Attribute.Position.Line   := yyLineCount;
  895. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  896. (* line 435 "cg.rex" *)
  897. RETURN TokRight        ;
  898. yyRestartFlag := FALSE; EXIT;
  899. |137
  900. :
  901. Attribute.Position.Line   := yyLineCount;
  902. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  903. (* line 436 "cg.rex" *)
  904. RETURN TokRule        ;
  905. yyRestartFlag := FALSE; EXIT;
  906. |134
  907. :
  908. Attribute.Position.Line   := yyLineCount;
  909. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  910. (* line 437 "cg.rex" *)
  911. RETURN TokScanner        ;
  912. yyRestartFlag := FALSE; EXIT;
  913. |128
  914. :
  915. Attribute.Position.Line   := yyLineCount;
  916. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  917. (* line 438 "cg.rex" *)
  918. RETURN TokSelect        ;
  919. yyRestartFlag := FALSE; EXIT;
  920. |123
  921. :
  922. Attribute.Position.Line   := yyLineCount;
  923. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  924. (* line 439 "cg.rex" *)
  925. RETURN TokStack        ;
  926. yyRestartFlag := FALSE; EXIT;
  927. |119
  928. :
  929. Attribute.Position.Line   := yyLineCount;
  930. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  931. (* line 440 "cg.rex" *)
  932. RETURN TokSubunit        ;
  933. yyRestartFlag := FALSE; EXIT;
  934. |35
  935. ,85
  936. :
  937. Attribute.Position.Line   := yyLineCount;
  938. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  939. (* line 441 "cg.rex" *)
  940. RETURN TokSynthesized    ;
  941. yyRestartFlag := FALSE; EXIT;
  942. |113
  943. :
  944. Attribute.Position.Line   := yyLineCount;
  945. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  946. (* line 442 "cg.rex" *)
  947. RETURN TokThread        ;
  948. yyRestartFlag := FALSE; EXIT;
  949. |108
  950. :
  951. Attribute.Position.Line   := yyLineCount;
  952. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  953. (* line 443 "cg.rex" *)
  954. RETURN TokTree        ;
  955. yyRestartFlag := FALSE; EXIT;
  956. |104
  957. :
  958. Attribute.Position.Line   := yyLineCount;
  959. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  960. (* line 444 "cg.rex" *)
  961. RETURN TokView        ;
  962. yyRestartFlag := FALSE; EXIT;
  963. |34
  964. :
  965. Attribute.Position.Line   := yyLineCount;
  966. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  967. (* line 445 "cg.rex" *)
  968. RETURN TokVirtual        ;
  969. yyRestartFlag := FALSE; EXIT;
  970. |17
  971. ,40
  972. ,41
  973. ,42
  974. ,52
  975. ,53
  976. ,54
  977. ,55
  978. ,56
  979. ,57
  980. ,58
  981. ,59
  982. ,60
  983. ,61
  984. ,62
  985. ,63
  986. ,64
  987. ,65
  988. ,66
  989. ,67
  990. ,68
  991. ,73
  992. ,74
  993. ,75
  994. ,76
  995. ,77
  996. ,78
  997. ,79
  998. ,80
  999. ,81
  1000. ,82
  1001. ,83
  1002. ,84
  1003. ,88
  1004. ,89
  1005. ,103
  1006. ,105
  1007. ,106
  1008. ,107
  1009. ,109
  1010. ,110
  1011. ,111
  1012. ,112
  1013. ,114
  1014. ,115
  1015. ,116
  1016. ,117
  1017. ,118
  1018. ,120
  1019. ,121
  1020. ,122
  1021. ,124
  1022. ,125
  1023. ,126
  1024. ,127
  1025. ,129
  1026. ,130
  1027. ,131
  1028. ,132
  1029. ,133
  1030. ,135
  1031. ,136
  1032. ,138
  1033. ,139
  1034. ,140
  1035. ,142
  1036. ,143
  1037. ,144
  1038. ,145
  1039. ,146
  1040. ,147
  1041. ,148
  1042. ,150
  1043. ,152
  1044. ,153
  1045. ,154
  1046. ,155
  1047. ,157
  1048. ,158
  1049. ,159
  1050. ,161
  1051. ,162
  1052. ,163
  1053. ,164
  1054. ,165
  1055. ,167
  1056. ,168
  1057. ,169
  1058. ,170
  1059. ,172
  1060. ,173
  1061. ,175
  1062. ,176
  1063. ,177
  1064. ,178
  1065. ,180
  1066. ,181
  1067. ,182
  1068. ,183
  1069. ,185
  1070. ,186
  1071. ,187
  1072. ,188
  1073. ,189
  1074. ,191
  1075. ,192
  1076. ,193
  1077. ,194
  1078. ,195
  1079. ,196
  1080. ,197
  1081. ,199
  1082. ,201
  1083. ,202
  1084. ,203
  1085. ,204
  1086. ,205
  1087. ,207
  1088. ,208
  1089. ,210
  1090. ,212
  1091. ,213
  1092. ,214
  1093. ,215
  1094. ,216
  1095. ,218
  1096. ,219
  1097. ,220
  1098. ,221
  1099. ,223
  1100. ,224
  1101. ,225
  1102. ,226
  1103. ,228
  1104. ,229
  1105. ,230
  1106. ,231
  1107. ,243
  1108. ,244
  1109. ,245
  1110. ,246
  1111. ,247
  1112. ,249
  1113. ,250
  1114. ,251
  1115. ,252
  1116. ,254
  1117. ,255
  1118. ,256
  1119. ,257
  1120. ,258
  1121. ,260
  1122. ,261
  1123. ,262
  1124. ,263
  1125. :
  1126. Attribute.Position.Line   := yyLineCount;
  1127. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  1128. (* line 447 "cg.rex" *)
  1129. GetWord (Word);
  1130.                        Attribute.Ident := MakeIdent (Word);
  1131.                RETURN TokIdentifier;
  1132. yyRestartFlag := FALSE; EXIT;
  1133. |33
  1134. :
  1135. Attribute.Position.Line   := yyLineCount;
  1136. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  1137. (* line 451 "cg.rex" *)
  1138. GetWord (Word);
  1139.                SubString (Word, 2, Length (Word), String);
  1140.                        Attribute.Ident := MakeIdent (String);
  1141.                RETURN TokIdentifier;
  1142. yyRestartFlag := FALSE; EXIT;
  1143. |95
  1144. :
  1145. (* BlankAction *)
  1146. WHILE yyChBufferPtr^ [yyChBufferIndex] = ' ' DO INC (yyChBufferIndex); END;
  1147. yyRestartFlag := FALSE; EXIT;
  1148. |94
  1149. :
  1150. (* TabAction *)
  1151. DEC (yyLineStart, 7 - (yyChBufferIndex - yyLineStart - 2) MOD 8);
  1152. yyRestartFlag := FALSE; EXIT;
  1153. |93
  1154. :
  1155. (* EolAction *)
  1156. INC (yyLineCount);
  1157. yyLineStart := yyChBufferIndex - 1;
  1158. yyRestartFlag := FALSE; EXIT;
  1159. |1
  1160. ,2
  1161. ,3
  1162. ,4
  1163. ,5
  1164. ,6
  1165. ,7
  1166. ,8
  1167. ,9
  1168. ,10
  1169. ,11
  1170. ,12
  1171. ,13
  1172. ,14
  1173. ,15
  1174. ,16
  1175. ,20
  1176. ,69
  1177. ,90
  1178. ,273
  1179. ,287
  1180. :
  1181.         (* non final states *)
  1182.           DEC (yyChBufferIndex);    (* return character *)
  1183.           DEC (TokenLength)        (* pop state *)
  1184.  
  1185. | 92:
  1186.           Attribute.Position.Line   := yyLineCount;
  1187.           Attribute.Position.Column := yyChBufferIndex - yyLineStart;
  1188.           INC (yyChBufferIndex);
  1189.           TokenLength := 1;
  1190. (* line 140 "cg.rex" *)
  1191.  
  1192.    GetWord (Word);
  1193.    Errors.MessageI ("illegal character", Errors.Error, Attribute.Position, Errors.String, ADR (Word));
  1194.    INC (ErrorCount);
  1195.  
  1196.               yyRestartFlag := FALSE; EXIT;
  1197.  
  1198.         |  yyDNoState    :        (* automatic initialization *)
  1199.           yyGetTables;
  1200.           yyStateStack^ [0] := yyDefaultState; (* stack underflow sentinel *)
  1201.           IF yyFileStackPtr = 0 THEN
  1202.              yyInitialize;
  1203.              yySourceFile := System.StdInput;
  1204.           END;
  1205.               yyRestartFlag := FALSE; EXIT;
  1206.  
  1207. | 91:
  1208.           DEC (yyChBufferIndex);    (* undo last state transition *)
  1209.           DEC (TokenLength);        (* get previous state *)
  1210.           IF TokenLength = 0 THEN
  1211.              yyState := yyStartState;
  1212.           ELSE
  1213.              yyState := yyStateStack^ [TokenLength];
  1214.           END;
  1215.  
  1216.           IF yyChBufferIndex # yyChBufferStart + yyBytesRead THEN
  1217.              yyState := yyEobTrans [yyState];    (* end of buffer sentinel in buffer *)
  1218.              IF yyState # yyDNoState THEN
  1219.             INC (yyChBufferIndex);
  1220.             INC (TokenLength);
  1221.             yyStateStack^ [TokenLength] := yyState;
  1222.             yyRestartFlag := TRUE; EXIT;
  1223.              END;
  1224.           ELSE                (* end of buffer reached *)
  1225.  
  1226.              (* copy initial part of token in front of input buffer *)
  1227.  
  1228.              yySource := yyChBufferIndex - TokenLength - 1;
  1229.              yyTarget := General.MaxAlign - TokenLength MOD General.MaxAlign - 1;
  1230.              IF yySource # yyTarget THEN
  1231.             FOR yyi := 1 TO TokenLength DO
  1232.                yyChBufferPtr^ [yyTarget + yyi] := yyChBufferPtr^ [yySource + yyi];
  1233.             END;
  1234.             DEC (yyLineStart, yySource - yyTarget);
  1235.             yyChBufferStart := yyTarget + TokenLength + 1;
  1236.              ELSE
  1237.             yyChBufferStart := yyChBufferIndex;
  1238.              END;
  1239.  
  1240.              IF NOT yyEof THEN        (* read buffer and restart *)
  1241.             yyChBufferFree := General.Exp2 (General.Log2 (yyChBufferSize - 4 - General.MaxAlign - TokenLength));
  1242.             IF yyChBufferFree < yyChBufferSize DIV 8 THEN
  1243.                DynArray.ExtendArray (yyChBufferPtr, yyChBufferSize, SYSTEM.TSIZE (CHAR));
  1244.                IF yyChBufferPtr = NIL THEN yyErrorMessage (1); END;
  1245.                yyChBufferFree := General.Exp2 (General.Log2 (yyChBufferSize - 4 - General.MaxAlign - TokenLength));
  1246.                IF yyStateStackSize < yyChBufferSize THEN
  1247.                   DynArray.ExtendArray (yyStateStack, yyStateStackSize, SYSTEM.TSIZE (yyStateRange));
  1248.                   IF yyStateStack = NIL THEN yyErrorMessage (1); END;
  1249.                END;
  1250.             END;
  1251.             yyChBufferIndex := yyChBufferStart;
  1252.             yyBytesRead := Source.GetLine (yySourceFile, SYSTEM.ADR
  1253.                (yyChBufferPtr^ [yyChBufferIndex]), yyChBufferFree);
  1254.             IF yyBytesRead <= 0 THEN yyBytesRead := 0; yyEof := TRUE; END;
  1255.             yyChBufferPtr^ [yyChBufferStart + yyBytesRead    ] := yyEobCh;
  1256.             yyChBufferPtr^ [yyChBufferStart + yyBytesRead + 1] := 0C;
  1257.             yyRestartFlag := TRUE; EXIT;
  1258.              END;
  1259.  
  1260.              IF TokenLength = 0 THEN    (* end of file reached *)
  1261.             Attribute.Position.Line   := yyLineCount;
  1262.             Attribute.Position.Column := yyChBufferIndex - yyLineStart;
  1263.             CloseFile;
  1264.             IF yyFileStackPtr = 0 THEN
  1265. (* line 146 "cg.rex" *)
  1266.  
  1267.    CASE yyStartState OF
  1268.    | targetcode    ,
  1269.      expr    : Errors.Message ("unclosed target code", Errors.Error, Attribute.Position);
  1270.           INC (ErrorCount);
  1271.  
  1272.    | comment    : Errors.Message ("unclosed comment", Errors.Error, Attribute.Position);
  1273.           INC (ErrorCount);
  1274.  
  1275.    | CStr1, CStr2,
  1276.      Str1, Str2    : Errors.Message ("unclosed string", Errors.Error, Attribute.Position);
  1277.           INC (ErrorCount);
  1278.    ELSE
  1279.    END;
  1280.    yyStart (STD);
  1281.    INC (CurArg);
  1282.    IF CurArg <= ArgCount THEN
  1283.       GetArgument (CurArg, Argument);
  1284.       j := 0;
  1285.       REPEAT
  1286.      ch := Argument [j];
  1287.      SourceFile [j] := ch;
  1288.      INC (j);
  1289.       UNTIL ch = 0C;
  1290.       BeginFile (SourceFile);
  1291.       ArrayToString (SourceFile, String);
  1292.       Attribute.Position.File := MakeIdent (String);
  1293.    END;
  1294.  
  1295.             END;
  1296.             IF yyFileStackPtr = 0 THEN RETURN EofToken; END;
  1297.             yyRestartFlag := FALSE; EXIT;
  1298.              END;
  1299.           END;
  1300.         ELSE
  1301.            yyErrorMessage (0);
  1302.         END;
  1303.      END;
  1304.      IF yyRestartFlag THEN ELSE EXIT; END;
  1305.       END;
  1306.    END;
  1307.    END GetToken;
  1308.  
  1309. PROCEDURE BeginFile (FileName: ARRAY OF CHAR);
  1310.    BEGIN
  1311.       IF yyStateStack^ [0] = yyDNoState THEN    (* have tables been read in ? *)
  1312.      yyGetTables;
  1313.      yyStateStack^ [0] := yyDefaultState;    (* stack underflow sentinel *)
  1314.       END;
  1315.       yyInitialize;
  1316.       yySourceFile := Source.BeginSource (FileName);
  1317.       IF yySourceFile < 0 THEN yyErrorMessage (5); END;
  1318.    END BeginFile;
  1319.  
  1320. PROCEDURE yyInitialize;
  1321.    BEGIN
  1322.       IF yyFileStackPtr >= yyFileStackSize THEN yyErrorMessage (3); END;
  1323.       INC (yyFileStackPtr);            (* push file *)
  1324.       WITH yyFileStack [yyFileStackPtr] DO
  1325.      SourceFile    := yySourceFile        ;
  1326.      Eof        := yyEof        ;
  1327.      ChBufferPtr    := yyChBufferPtr    ;
  1328.      ChBufferStart    := yyChBufferStart    ;
  1329.      ChBufferSize    := yyChBufferSize    ;
  1330.      ChBufferIndex    := yyChBufferIndex    ;
  1331.      BytesRead    := yyBytesRead        ;
  1332.      LineCount    := yyLineCount        ;
  1333.      LineStart    := yyLineStart        ;
  1334.       END;
  1335.                         (* initialize file state *)
  1336.       yyChBufferSize    := yyInitBufferSize;
  1337.       DynArray.MakeArray (yyChBufferPtr, yyChBufferSize, SYSTEM.TSIZE (CHAR));
  1338.       IF yyChBufferPtr = NIL THEN yyErrorMessage (1); END;
  1339.       yyChBufferStart    := General.MaxAlign;
  1340.       yyChBufferPtr^ [yyChBufferStart - 1] := yyEolCh; (* begin of line indicator *)
  1341.       yyChBufferPtr^ [yyChBufferStart    ] := yyEobCh; (* end of buffer sentinel *)
  1342.       yyChBufferPtr^ [yyChBufferStart + 1] := 0C;
  1343.       yyChBufferIndex    := yyChBufferStart;
  1344.       yyEof        := FALSE;
  1345.       yyBytesRead    := 0;
  1346.       yyLineCount    := 1;
  1347.       yyLineStart    := yyChBufferStart - 1;
  1348.    END yyInitialize;
  1349.  
  1350. PROCEDURE CloseFile;
  1351.    BEGIN
  1352.       IF yyFileStackPtr = 0 THEN yyErrorMessage (4); END;
  1353.       Source.CloseSource (yySourceFile);
  1354.       DynArray.ReleaseArray (yyChBufferPtr, yyChBufferSize, SYSTEM.TSIZE (CHAR));
  1355.       WITH yyFileStack [yyFileStackPtr] DO    (* pop file *)
  1356.      yySourceFile    := SourceFile        ;
  1357.      yyEof        := Eof            ;
  1358.      yyChBufferPtr    := ChBufferPtr        ;
  1359.      yyChBufferStart:= ChBufferStart    ;
  1360.      yyChBufferSize    := ChBufferSize        ;
  1361.      yyChBufferIndex:= ChBufferIndex    ;
  1362.      yyBytesRead    := BytesRead        ;
  1363.      yyLineCount    := LineCount        ;
  1364.      yyLineStart    := LineStart        ;
  1365.       END;
  1366.       DEC (yyFileStackPtr);        
  1367.    END CloseFile;
  1368.  
  1369. PROCEDURE GetWord (VAR Word: Strings.tString);
  1370.    VAR i, WordStart    : INTEGER;
  1371.    BEGIN
  1372.       WordStart := yyChBufferIndex - TokenLength - 1;
  1373.       FOR i := 1 TO TokenLength DO
  1374.      Word.Chars [i] := yyChBufferPtr^ [WordStart + i];
  1375.       END;
  1376.       Word.Length := TokenLength;
  1377.    END GetWord;
  1378.  
  1379. PROCEDURE GetLower (VAR Word: Strings.tString);
  1380.    VAR i, WordStart    : INTEGER;
  1381.    BEGIN
  1382.       WordStart := yyChBufferIndex - TokenLength - 1;
  1383.       FOR i := 1 TO TokenLength DO
  1384.      Word.Chars [i] := yyToLower [yyChBufferPtr^ [WordStart + i]];
  1385.       END;
  1386.       Word.Length := TokenLength;
  1387.    END GetLower;
  1388.  
  1389. PROCEDURE GetUpper (VAR Word: Strings.tString);
  1390.    VAR i, WordStart    : INTEGER;
  1391.    BEGIN
  1392.       WordStart := yyChBufferIndex - TokenLength - 1;
  1393.       FOR i := 1 TO TokenLength DO
  1394.      Word.Chars [i] := yyToUpper [yyChBufferPtr^ [WordStart + i]];
  1395.       END;
  1396.       Word.Length := TokenLength;
  1397.    END GetUpper;
  1398.  
  1399. PROCEDURE yyStart (State: yyStateRange);
  1400.    BEGIN
  1401.       yyPreviousStart    := yyStartState;
  1402.       yyStartState    := State;
  1403.    END yyStart;
  1404.  
  1405. PROCEDURE yyPrevious;
  1406.    VAR s    : yyStateRange;
  1407.    BEGIN
  1408.       s              := yyStartState;
  1409.       yyStartState    := yyPreviousStart;
  1410.       yyPreviousStart := s;
  1411.    END yyPrevious;
  1412.  
  1413. PROCEDURE yyEcho;
  1414.    VAR i    : INTEGER;
  1415.    BEGIN
  1416.       FOR i := yyChBufferIndex - TokenLength TO yyChBufferIndex - 1 DO
  1417.      IO.WriteC (IO.StdOutput, yyChBufferPtr^ [i]);
  1418.       END;
  1419.    END yyEcho;
  1420.  
  1421. PROCEDURE yyLess (n: INTEGER);
  1422.    BEGIN
  1423.       DEC (yyChBufferIndex, TokenLength - n);
  1424.       TokenLength := n;
  1425.    END yyLess;
  1426.  
  1427. PROCEDURE yyTab;
  1428.    BEGIN
  1429.       DEC (yyLineStart, yyTabSpace - 1 - (yyChBufferIndex - yyLineStart - 2) MOD yyTabSpace);
  1430.    END yyTab;
  1431.  
  1432. PROCEDURE yyTab1 (a: INTEGER);
  1433.    BEGIN
  1434.       DEC (yyLineStart, yyTabSpace - 1 - (yyChBufferIndex - yyLineStart - TokenLength + a - 1) MOD yyTabSpace);
  1435.    END yyTab1;
  1436.  
  1437. PROCEDURE yyTab2 (a, b: INTEGER);
  1438.    BEGIN
  1439.       DEC (yyLineStart, yyTabSpace - 1 - (yyChBufferIndex - yyLineStart - TokenLength + a - 1) MOD yyTabSpace);
  1440.    END yyTab2;
  1441.  
  1442. PROCEDURE yyEol (Column: INTEGER);
  1443.    BEGIN
  1444.       INC (yyLineCount);
  1445.       yyLineStart := yyChBufferIndex - 1 - Column;
  1446.    END yyEol;
  1447.  
  1448. PROCEDURE output (c: CHAR);
  1449.    BEGIN
  1450.       IO.WriteC (IO.StdOutput, c);
  1451.    END output;
  1452.  
  1453. PROCEDURE unput (c: CHAR);
  1454.    BEGIN
  1455.       DEC (yyChBufferIndex);
  1456.       yyChBufferPtr^ [yyChBufferIndex] := c;
  1457.    END unput;
  1458.  
  1459. PROCEDURE input (): CHAR;
  1460.    BEGIN
  1461.       IF yyChBufferIndex = yyChBufferStart + yyBytesRead THEN
  1462.      IF NOT yyEof THEN
  1463.         DEC (yyLineStart, yyBytesRead);
  1464.         yyChBufferIndex := 0;
  1465.         yyChBufferStart := 0;
  1466.         yyBytesRead := Source.GetLine (yySourceFile, yyChBufferPtr, General.Exp2 (General.Log2 (yyChBufferSize)));
  1467.         IF yyBytesRead <= 0 THEN yyBytesRead := 0; yyEof := TRUE; END;
  1468.         yyChBufferPtr^ [yyBytesRead    ] := yyEobCh;
  1469.         yyChBufferPtr^ [yyBytesRead + 1] := 0C;
  1470.      END;
  1471.       END;
  1472.       IF yyChBufferIndex = yyChBufferStart + yyBytesRead THEN
  1473.      RETURN 0C;
  1474.       ELSE
  1475.      INC (yyChBufferIndex);
  1476.      RETURN yyChBufferPtr^ [yyChBufferIndex - 1];
  1477.       END
  1478.    END input;
  1479.  
  1480. PROCEDURE BeginScanner;
  1481.    BEGIN
  1482. (* line 138 "cg.rex" *)
  1483.  NestingLevel := 0; 
  1484.    END BeginScanner;
  1485.  
  1486. PROCEDURE CloseScanner;
  1487.    BEGIN
  1488.    END CloseScanner;
  1489.  
  1490. PROCEDURE yyGetTables;
  1491.    VAR
  1492.       BlockSize, j, n    : CARDINAL;
  1493.       TableFile    : System.tFile;
  1494.       i        : yyStateRange;
  1495.       Base    : ARRAY yyStateRange OF yyTableRange;
  1496.    BEGIN
  1497.       BlockSize    := 64000 DIV SYSTEM.TSIZE (yyCombType);
  1498.       TableFile := System.OpenInput (ScanTabName);
  1499.       Checks.ErrorCheck ("yyGetTables.OpenInput", TableFile);
  1500.       IF (yyGetTable (TableFile, SYSTEM.ADR (Base      )) DIV SYSTEM.TSIZE (yyTableElmt) - 1 # yyDStateCount) OR
  1501.          (yyGetTable (TableFile, SYSTEM.ADR (yyDefault )) DIV SYSTEM.TSIZE (yyTableElmt) - 1 # yyDStateCount) OR
  1502.          (yyGetTable (TableFile, SYSTEM.ADR (yyEobTrans)) DIV SYSTEM.TSIZE (yyTableElmt) - 1 # yyDStateCount)
  1503.      THEN
  1504.      yyErrorMessage (2);
  1505.       END;
  1506.       n := 0;
  1507.       j := 0;
  1508.       WHILE j <= yyTableSize DO
  1509.          INC (n, yyGetTable (TableFile, SYSTEM.ADR (yyComb [j])) DIV SYSTEM.TSIZE (yyCombType));
  1510.          INC (j, BlockSize);
  1511.       END;
  1512.       IF n # yyTableSize + 1 THEN yyErrorMessage (2); END;
  1513.       System.Close (TableFile);
  1514.  
  1515.       FOR i := 0 TO yyDStateCount DO
  1516.      yyBasePtr [i] := LONGCARD (SYSTEM.ADR (yyComb [Base [i]]));
  1517.       END;
  1518.    END yyGetTables;
  1519.  
  1520. PROCEDURE yyGetTable (TableFile: System.tFile; Address: SYSTEM.ADDRESS): CARDINAL;
  1521.    VAR
  1522.       N        : INTEGER;
  1523.       Length    : yyTableElmt;
  1524.    BEGIN
  1525.       N := System.Read (TableFile, SYSTEM.ADR (Length), SYSTEM.TSIZE (yyTableElmt));
  1526.       Checks.ErrorCheck ("yyGetTable.Read1", N);
  1527.       N := System.Read (TableFile, Address, Length);
  1528.       Checks.ErrorCheck ("yyGetTable.Read2", N);
  1529.       RETURN Length;
  1530.    END yyGetTable;
  1531.  
  1532. PROCEDURE yyErrorMessage (ErrorCode: SHORTCARD);
  1533.    BEGIN
  1534.       Positions.WritePosition (IO.StdError, Attribute.Position);
  1535.       CASE ErrorCode OF
  1536.    | 0: IO.WriteS (IO.StdError, ": Scanner: internal error");
  1537.    | 1: IO.WriteS (IO.StdError, ": Scanner: out of memory");
  1538.    | 2: IO.WriteS (IO.StdError, ": Scanner: table mismatch");
  1539.    | 3: IO.WriteS (IO.StdError, ": Scanner: too many nested include files");
  1540.    | 4: IO.WriteS (IO.StdError, ": Scanner: file stack underflow (too many calls of CloseFile)");
  1541.    | 5: IO.WriteS (IO.StdError, ": Scanner: cannot open input file");
  1542.       END;
  1543.       IO.WriteNl (IO.StdError); Exit;
  1544.    END yyErrorMessage;
  1545.  
  1546. PROCEDURE yyExit;
  1547.    BEGIN
  1548.       IO.CloseIO; System.Exit (1);
  1549.    END yyExit;
  1550.  
  1551. BEGIN
  1552.    ScanTabName        := "Scanner.Tab";
  1553.    Exit            := yyExit;
  1554.    yyFileStackPtr    := 0;
  1555.    yyStartState        := 1;            (* set up for auto init *)
  1556.    yyPreviousStart    := 1;
  1557.    yyBasePtr [yyStartState] := LONGCARD (SYSTEM.ADR (yyComb [0]));
  1558.    yyDefault [yyStartState] := yyDNoState;
  1559.    yyComb [0].Check    := yyDNoState;
  1560.    yyChBufferPtr    := SYSTEM.ADR (yyComb [0]);    (* dirty trick *)
  1561.    yyChBufferIndex    := 1;                (* dirty trick *)
  1562.    yyStateStackSize    := yyInitBufferSize;
  1563.    DynArray.MakeArray (yyStateStack, yyStateStackSize, SYSTEM.TSIZE (yyStateRange));
  1564.    yyStateStack^ [0]    := yyDNoState;
  1565.    
  1566.    FOR yyCh := yyFirstCh TO yyLastCh DO yyToLower [yyCh] := yyCh; END;
  1567.    yyToUpper := yyToLower;
  1568.    FOR yyCh := 'A' TO 'Z' DO
  1569.       yyToLower [yyCh] := CHR (ORD (yyCh) - ORD ('A') + ORD ('a'));
  1570.    END;
  1571.    FOR yyCh := 'a' TO 'z' DO
  1572.       yyToUpper [yyCh] := CHR (ORD (yyCh) - ORD ('a') + ORD ('A'));
  1573.    END;
  1574. END Scanner.
  1575.